/*
滑雪
给定一个R行C列的矩阵，表示一个矩阵网格滑雪场。
一个人从滑雪场中的某个区域内出发，每次可以向上下左右任意一个方向滑动一个单位距离。
当然，一个人能够滑动到某相邻区域的前提是该区域的高度低于自己目前所在区域的高度。
下面给出一个矩阵作为例子：
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9
在给定矩阵中，一条可行的滑行轨迹为24-17-2-1。
在给定矩阵中，最长的滑行轨迹为25-24-23-…3-2-1，沿途共经过25个区域。
现在给定你一个二维矩阵表示滑雪场各区域的高度，请你找出在该滑雪场中能够完成的最长滑雪轨迹，并输出其长度（可经过最大区域数）。

输入格式
第一行包含两个整数R和C。
接下来R行，每行包含C个整数，表示完整的二维矩阵。

输出格式
输出一个整数，表示可完成的最长滑雪长度。

数据范围
1≤R，C≤300,
0≤矩阵中整数≤10000

输入样例：
5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

输出样例：
25
 */

import java.util.*;

public class Main {
    static int r, c;
    static int[][] g = new int[305][305];
    static int[][] dp = new int[305][305];
    static final int[] dx = {-1, 0, 1, 0};
    static final int[] dy = {0, 1, 0, -1};

    static int dfs(int i, int j) {
        dp[i][j] = 1;
        for (int k = 0; k < 4; k++) {
            int nx = i + dx[k], ny = j + dy[k];
            if (nx >= 1 && nx <= r && ny >= 1 && ny <= c && g[nx][ny] < g[i][j]) {
                dp[i][j] = Math.max(dp[i][j], dfs(nx, ny) + 1);
            }
        }
        return dp[i][j];
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        r = sc.nextInt();
        c = sc.nextInt();
        for (int i = 1; i <= r; i++) {
            for (int j = 1; j <= c; j++) {
                g[i][j] = sc.nextInt();
            }
        }
        for (int[] row : dp) {
            Arrays.fill(row, -1);
        }
        int res = 0;
        for (int i = 1; i <= r; i++) {
            for (int j = 1; j <= c; j++) {
                res = Math.max(res, dfs(i, j));
            }
        }
        System.out.println(res);
    }
}